class ConteudoController < ApplicationController

before_filter :login_required, :except=>['index']
#require 'conteudo_filtro'
require 'RMagick'

uses_tiny_mce(:options => {
       #:language=>'pt_br',
       :mode => 'exact',
       :elements => "extra_texto",
       :theme => 'advanced',
		   :browsers => %w{msie gecko},
		   :theme_advanced_toolbar_location => "bottom",
		   :theme_advanced_toolbar_align => "left",
		   :theme_advanced_styles => "Titulao=titulao; Titulinho=titulinho; Destaque=destaque; Legenda=legenda",
		   :theme_advanced_resizing => true,
		   :theme_advanced_resize_horizontal => false,
		   :paste_auto_cleanup_on_paste => true,
		   :width => "500",
		   :height => "400",
		   :theme_advanced_buttons1 => %w{formatselect bold italic underline  justifyleft justifycenter justifyright indent outdent separator bullist numlist link unlink image undo redo},
		   :theme_advanced_buttons2 => [],
		   :theme_advanced_buttons3 => [],
		   :plugins => %w{ts_advimage contextmenu paste}},
       :execcommand_callback => "myCustomExecCommandHandler",
       :only => [:editar])

  # decide o id e redireciona (pensar para onde redirecionar (filhos ou ver))
  # se vai pra filhos, fica rodando sem parar...
  # melhor ir para ver e colocar barra de comandos sobre os textos.
  def index
    if(params[:id].nil?)
      @conteudo = Conteudo.pegar_conteudo_padrao
      id = @conteudo.id
    else
      id = params[:id]
    end
    redirect_to(filhos_conteudo_url(id)) 
  end

  def new
    render :text=>'novo conteúdo'
  end
  
  def create
    raise "método create não implementado. Usar a rota member criar. Futuramente este aqui pode servir para criar novo site. "
  end
  
  def criar_filho
    conteudo_pai = Conteudo.find(params[:id])
    conteudo_pai.criar(params[:config_conteudo_id],current_user)
    redirect_to(filhos_conteudo_url(conteudo_pai))
  end

  def destroy
    conteudo = Conteudo.find(params[:id])
    conteudo.destroy
    s = render_to_string :partial=>'lista_filhos',:locals=>{:conteudo=>conteudo.parent}
    render :update do |page|
      ConteudoController.crossfade(page, 'mensagem_flash') do
        page.replace_html "lista_filhos", s 
        page.replace_html "mensagem_flash",conteudo.nome << " removido com sucesso. "
      end
    end
  end

  def show
    puts('CONTEUDO SHOW')
    if(params[:id].nil?)
      @conteudo = Conteudo.pegar_conteudo_padrao
      id = @conteudo.id
      # para o conteudo padrao sempre ser liberado, evitando bug de redirecionamento eterno....
      tem_permissao = true 
    else
      id = params[:id]
      tem_permissao = true#tem_permissao?( params[:controller] , params[:action] , id ) 
    end
    if tem_permissao
      @conteudo = @conteudo || Conteudo.find(id)
      render :inline=>@conteudo.texto_tpl, 
             :locals=>{:conteudo=>@conteudo,:extra=>@conteudo.extra},
             :layout=>'padrao_front'
    else
      msg = "Desculpe, mas voce nao tem permissao para acessar este conteudo."
      flash[:error] = msg
      access_denied
    end
  end

  def prever
    if(params[:id].nil?)
      @conteudo = Conteudo.pegar_conteudo_padrao
      id = @conteudo.id
      # para o conteudo padrao sempre ser liberado, evitando bug de redirecionamento eterno....
      tem_permissao = true 
    else
      id = params[:id]
      tem_permissao = tem_permissao?( params[:controller] , params[:action] , id ) 
    end
    if tem_permissao
      @conteudo = @conteudo || Conteudo.find(id)
      render :inline=>@conteudo.texto_tpl, 
             :locals=>{:conteudo=>@conteudo,:extra=>@conteudo.extra},
       :layout=>'padrao_front'
    else
      msg = "Desculpe, mas voce nao tem permissao para acessar este conteudo."
      flash[:error] = msg
      access_denied
    end
  end

  def prever_imagem
    conteudo = Conteudo.find(params[:id])
    cont_imagem = conteudo.extra
    send_file(  cont_imagem.full_filename(params[:tipo]),
                :disposition => 'inline',
                :type => cont_imagem.content_type,
                :stream => false,
                :filename => cont_imagem.filename ) 
  end

  def imagem
    conteudo = Conteudo.find(params[:id])
    cont_imagem = conteudo.extra
    send_file(  cont_imagem.full_filename(params[:tipo]),
                :disposition => 'inline',
                :type => cont_imagem.content_type,
                :stream => false,
                :filename => cont_imagem.filename ) 
  end

  def self.crossfade(page, *dom_ids)
    dom_ids.each do |dom_id|
      page.visual_effect(:fade, dom_id, :duration => 0.5)
    end
    page.delay 0.5 do
      yield
      dom_ids.each do |dom_id|
        page.visual_effect(:appear, dom_id, :duration => 0.5)
      end
    end
  end

#  def show
#    @conteudo = Conteudo.find(params[:id])
#    begin 
#      @resultado = render_component_as_string(
#                                            :controller => 'conteudo_front', 
#                                            :action => 'ver',
#                                            :id=>params[:id]
#      )
#    rescue 
#      @resultado = "erro ao gerar visualização (veja sintaxe do tpl)."
#    end
#  end

#  def show
#    @conteudo = Conteudo.find(params[:id])
#    begin 
#      @resultado = render_component_as_string(
#                                            :controller => 'conteudo_front', 
#                                            :action => 'ver',
#                                            :id=>params[:id]
#      )
#    rescue 
#      @resultado = "erro ao gerar visualização (veja sintaxe do tpl)."
#    end
#  end
  
  def edit(busca_sessao = false)
    @conteudo = Conteudo.find(params[:id])
  end

  def update
    @conteudo = Conteudo.find(params[:id])
    if @conteudo.salvar_tudo(params[:conteudo],params[:extra])
      flash[:error] = "Conteudo foi salvo tranquilamente"
    else
      flash[:error] = "Não salvou por isso isso e aquilo..."
    end
    respond_to do |accepts|
        accepts.js do
          render :update do |page|
             page.replace_html "mensagem_flash", flash[:error]
          end
        end
        accepts.html do
          redirect_to edit_conteudo_url(@conteudo)
        end
    end
  end
  
  def filhos
    @conteudo = Conteudo.find(params[:id])
  end
  
  #move o conte�do para depois do pr�ximo filho do mesmo pai
  def avancar
    conteudo = Conteudo.find(params[:id])
    conteudo.avancar
    s = render_to_string :partial=>'lista_filhos',:locals=>{:conteudo=>conteudo.parent}
    puts s
    render :update do |page|
      ConteudoController.crossfade(page, 'mensagem_flash',"lista_filhos") do
        page.replace_html "lista_filhos", s
        #page.replace_html "lista_filhos","qualquer coisa!"
        page.replace_html "mensagem_flash",conteudo.nome << " movido com sucesso. "
      end
    end
  end
  
  #move o conte�do para antes do pr�ximo filho do mesmo pai
  def voltar
    conteudo = Conteudo.find(params[:id])
    conteudo.voltar
    s = render_to_string :partial=>'lista_filhos',:locals=>{:conteudo=>conteudo.parent}
    puts s
    render :update do |page|
      ConteudoController.crossfade(page, 'mensagem_flash',"lista_filhos") do
        pp conteudo.parent
        page.replace_html "lista_filhos",s
        page.replace_html "mensagem_flash",conteudo.nome << " movido com sucesso. "
      end
    end
  end
  
#  # � USADO AINDA?
#  def before_update_save(record)
#    categorias_para_relacionar = Hash.new
#    params[:record][:categorias_para_relacionar].each_pair do |k,v|
#      categorias_para_relacionar[k.to_i] = v.to_i
#    end
#    record.categorias_para_relacionar = categorias_para_relacionar
#  end

  ################ PERMISSOES

  def permissoes
    @conteudo = Conteudo.find(params[:id])
    @grupos = Grupo.find(:all)
    @papeis = Papel.find(:all,:conditions=>'especifico_conteudo = 1')
    @permissoes = Permissao.permissoes_para_conteudo_indexadas(@conteudo.id)
    #ESSA LINHA � USADA PARA CRIAR AS NOVAS PERMISSOES, QUANDO INEXISTENTES AINDA.  
    #POR ALGUM MOTIVO MISTERIOSO COME�OU A DAR UM BUG DE LOOP ETERNO QUANDO DESCOMENTADA
    #@permissoes = CaPermissao.inicializar_permissoes_conteudo_inexistentes(permissoes,@grupos,@papeis,@conteudo.id)
  end

  def ver_permissoes
    @conteudo = Conteudo.find(params[:id])
    @grupos = Grupo.find(:all)
    @papeis = Papel.find(:all,:conditions=>'especifico_conteudo = 1')
    @permissoes = CaPermissao.permissoes_para_conteudo_indexadas(@conteudo.id)
    #ESSA LINHA � USADA PARA CRIAR AS NOVAS PERMISSOES, QUANDO INEXISTENTES AINDA.  
    #POR ALGUM MOTIVO MISTERIOSO COME�OU A DAR UM BUG DE LOOP ETERNO QUANDO DESCOMENTADA
    #@permissoes = CaPermissao.inicializar_permissoes_conteudo_inexistentes(permissoes,@grupos,@papeis,@conteudo.id)
  end
  
  
  def salvar_permissoes
    #deb(params)
    @conteudo = Conteudo.find(params[:id])
    @grupos = Grupo.find(:all)
    @papeis = Papel.find(:all,:conditions=>'especifico_conteudo = 1')
    @permissoes = CaPermissao.permissoes_para_conteudo_indexadas(@conteudo.id)
    #ESSA LINHA � USADA PARA CRIAR AS NOVAS PERMISSOES, QUANDO INEXISTENTES AINDA, SE O BANCO N ESTIVER INTEGRO.
    #@permissoes = CaPermissao.inicializar_permissoes_conteudo_inexistentes(permissoes,@grupos,@papeis,@conteudo.id)
    @grupos.each do |g|
      @papeis.each do |pa|
        permissao_carregada = @permissoes[g.id][pa.id]
        case params[:permissao][g.id.to_s][pa.id.to_s]
          when 'sim'
            herdar = false
            tem_acesso = true
          when 'nao'
            herdar = false
            tem_acesso = false
          when 'herdar'
            herdar = true
        end
        # diz se grava a permissao ou mantem
        gravar = false
        # se criou nova permissao, pois antes n�o existia no banco (ver comentario antes do each)
        gravar = true if( permissao_carregada.nova? )
        # se trocou o valor de herdar
        gravar = true if( permissao_carregada.herdar != herdar)
        # se manteve dizendo para nao herdar, mas trocou o acesso
        gravar = true if( (permissao_carregada.herdar == herdar) && (!herdar) && (permissao_carregada.tem_acesso != tem_acesso) )
        if(gravar)
          permissao_carregada.herdar = herdar
          if(permissao_carregada.herdar)
            permissao_carregada.herdar_valor
          else
            permissao_carregada.tem_acesso = tem_acesso
          end
          permissao_carregada.gravar
          # ver possivel otimiza��o do m�todo abaixo, deve ficar lento com o tempo.
          permissao_carregada.atualiza_filhos
        end
      end
    end
    redirect_to :action => :permissoes, :id => @conteudo.id
  end

  #################################################################

#  def conditions_for_collection
#    @conteudo_filtro = ConteudoFiltro.new(ConfigConteudo.ids_e_nomes)
#    sql_filtro = ""
#    require 'pp'
#    pp params
#    if(params.key?(:filtro))
#      ids_config_conteudo = []
#      if !params[:filtro][:config_conteudo_id].nil?
#        params[:filtro][:config_conteudo_id].each do |id,ativo|
#	  id = id.to_i
#	  if ativo.eql?("1")
#            @conteudo_filtro.ativar_tipo_conteudo(id)
#	    ids_config_conteudo << id
#	  end
#        end
#      end
#      if (ids_config_conteudo.size > 0)
#        sql_filtro << " config_conteudo_id in ("+ids_config_conteudo.join(',')+")"
#      end
#      ids_categorias = {}
#      params[:filtro][:categorizacao].each do |id,dados|
#        if dados["ativar"].eql?("1")
#          @conteudo_filtro.ativar_categorizacao(
#	                                    id.to_i,
#					    dados["categoria_id"].to_i,
#					    (dados["inclui_filhos"].eql?("1"))
#	  )
#	  ids_categorias[dados["categoria_id"].to_i] = ( dados["inclui_filhos"].eql?("1") ? id.to_i : false )
#	end  #if
#      end  #each
#      sql_filtro << " AND conteudo_id in ("+Categoria.sql_ids_conteudos_categorias(ids_categorias)+")" if ids_categorias.size > 0
#    end
#    sql_filtro 
#  end
  
  def imagem
    imagem = ConteudoImagem.find(params[:id])
    send_data(imagem.data,
      :filename => imagem.nome,
      :type => imagem.tipo,
      :disposition => "inline")
  end


#  def enviar_imagem
#    conteudo_imagem = ConteudoImagem.novo(params[:imagem],session[:conteudo].id)
#    session[:conteudo].conteudo_imagem << conteudo_imagem
#    resultado = conteudo_imagem.save
#    if resultado
#      flash[:mensagem] = "Imagem Recebida com Sucesso"
#    else
#      flash[:mensagem] = "Erro ao Receber Imagem ... " + conteudo_imagem.errors
#    end
#    redirect_to( :action => :editar, :busca_sessao => true )
#  end

  def remover_imagem
    conteudo_imagem = ConteudoImagem.find(params[:id])
    @conteudo = session[:conteudo]
    ainda_tem_imagem_no_conteudo = false
    @conteudo.conteudo_pagina.each do |cp|
      if(cp.ordem != @conteudo.num_pagina_atual && cp.texto.include?(conteudo_imagem.caminho_imagem))
        ainda_tem_imagem_no_conteudo = true
      end
    end
    if(ainda_tem_imagem_no_conteudo) 
      msg = "A imagem ainda está no conteúdo e por isso não pode ser removida."
    else
      conteudo_imagem.destroy
      msg = "Imagem Removida com Sucesso."
    end
    render :update do |page|
      if(!ainda_tem_imagem_no_conteudo)
        page.replace_html "imagens", :partial=>"conteudo/mostrar_lista_imagens", :locals=>{:imagens=>@conteudo.conteudo_imagem}
      end
      page.replace_html "mensagens" , msg
    end
  end

  #def informacoes
  #  @conteudo = Conteudo.find(params[:id])
  #end

end